import { http } from "@/utils/http";

/** 统一响应格式 */
export interface ApiResponse<T = any> {
  /** 状态码 */
  code: number;
  /** 响应消息 */
  message: string;
  /** 响应数据 */
  data?: T;
  /** 时间戳 */
  timestamp?: number;
}

// ==================== 用户注册相关接口 ====================

/** 用户注册请求参数 */
export interface UserRegisterRequest {
  /** 用户名，3-20字符，只能包含字母数字下划线 */
  userName: string;
  /** 密码，6-20字符 */
  password: string;
  /** 确认密码，必须与密码一致 */
  confirmPassword: string;
  /** 用户昵称，2-20字符 */
  nickName: string;
  /** 邮箱地址，必须符合邮箱格式 */
  email: string;
  /** 手机号码，11位数字 */
  phonenumber?: string;
  /** 性别，0-女，1-男 */
  sex?: string;
  /** 邮箱验证码，6位数字，如果提供则进行邮箱验证 */
  emailVerificationCode?: string;
  /** 是否需要邮箱验证，默认false */
  requireEmailVerification?: boolean;
}

/** 用户登录请求参数 */
export interface UserLoginRequest {
  /** 用户名 */
  userName: string;
  /** 密码 */
  password: string;
}

/** 用户认证响应数据 */
export interface UserAuthData {
  /** JWT令牌 */
  token: string;
  /** 用户ID */
  userId: number;
  /** 用户名 */
  userName: string;
  /** 用户昵称 */
  nickName: string;
  /** 头像URL */
  avatar?: string;
  /** 角色列表 */
  roles: string[];
  /** 权限列表 */
  permissions: string[];
  /** Token过期时间(秒) */
  expireTime: number;
}

/** 用户注册响应结果 */
export type UserRegisterResult = ApiResponse<UserAuthData>;

/** 用户登录响应结果 */
export type UserLoginResult = ApiResponse<UserAuthData>;

/** 用户注销响应结果 */
export type UserLogoutResult = ApiResponse;

/** 获取用户信息响应结果 */
export type UserInfoResult = ApiResponse<UserAuthData>;

/** 刷新Token响应结果 */
export type RefreshTokenResult = ApiResponse<UserAuthData>;

// ==================== 邮箱验证相关接口 ====================

/** 验证类型枚举 */
export enum VerificationType {
  /** 注册验证 */
  REGISTER = "REGISTER",
  /** 密码重置 */
  RESET_PASSWORD = "RESET_PASSWORD",
  /** 更换邮箱 */
  CHANGE_EMAIL = "CHANGE_EMAIL"
}

/** 发送邮箱验证码请求参数 */
export interface SendVerificationCodeRequest {
  /** 邮箱地址，必须符合邮箱格式 */
  email: string;
  /** 验证类型 */
  verificationType: VerificationType;
}

/** 发送邮箱验证码响应数据 */
export interface SendVerificationCodeData {
  /** 是否成功 */
  success: boolean;
  /** 响应消息 */
  message: string;
  /** 验证码过期时间(分钟) */
  expireMinutes: number;
  /** 下次发送间隔时间(秒) */
  nextSendSeconds?: number;
  /** 剩余发送次数 */
  remainingSendCount?: number;
}

/** 发送邮箱验证码响应结果 */
export type SendVerificationCodeResult = ApiResponse<SendVerificationCodeData>;

/** 验证邮箱验证码请求参数 */
export interface VerifyEmailCodeRequest {
  /** 邮箱地址 */
  email: string;
  /** 验证码，6位数字 */
  verificationCode: string;
  /** 验证类型 */
  verificationType: VerificationType;
}

/** 验证邮箱验证码响应结果 */
export type VerifyEmailCodeResult = ApiResponse;

// ==================== 密码重置相关接口 ====================

/** 忘记密码请求参数 */
export interface ForgotPasswordRequest {
  /** 邮箱地址 */
  email: string;
}

/** 忘记密码响应数据 */
export interface ForgotPasswordData {
  /** 是否成功 */
  success: boolean;
  /** 响应消息 */
  message: string;
  /** 重置链接过期时间(分钟) */
  expireMinutes: number;
}

/** 忘记密码响应结果 */
export type ForgotPasswordResult = ApiResponse<ForgotPasswordData>;

/** 验证重置令牌响应结果 */
export type ValidateResetTokenResult = ApiResponse;

/** 重置密码请求参数 */
export interface ResetPasswordRequest {
  /** 重置令牌 */
  resetToken: string;
  /** 新密码，6-20字符 */
  newPassword: string;
  /** 确认密码，必须与新密码一致 */
  confirmPassword: string;
}

/** 重置密码响应结果 */
export type ResetPasswordResult = ApiResponse;

// ==================== API接口函数 ====================

/** 用户注册 */
export const userRegisterApi = (data: UserRegisterRequest) => {
  return http.request<UserRegisterResult>("post", "/user/auth/register", {
    data
  });
};

/** 用户登录 */
export const userLoginApi = (data: UserLoginRequest) => {
  return http.request<UserLoginResult>("post", "/user/auth/login", { data });
};

/** 用户注销 */
export const userLogoutApi = () => {
  return http.request<UserLogoutResult>("post", "/user/auth/logout");
};

/** 获取当前用户信息 */
export const getUserInfoApi = () => {
  return http.request<UserInfoResult>("get", "/user/auth/userinfo");
};

/** 刷新Token */
export const refreshUserTokenApi = () => {
  return http.request<RefreshTokenResult>("post", "/user/auth/refresh");
};

/** 发送邮箱验证码 */
export const sendVerificationCodeApi = (data: SendVerificationCodeRequest) => {
  return http.request<SendVerificationCodeResult>(
    "post",
    "/user/auth/send-verification-code",
    { data }
  );
};

/** 验证邮箱验证码 */
export const verifyEmailCodeApi = (data: VerifyEmailCodeRequest) => {
  return http.request<VerifyEmailCodeResult>(
    "post",
    "/user/auth/verify-email-code",
    { data }
  );
};

/** 忘记密码 */
export const forgotPasswordApi = (data: ForgotPasswordRequest) => {
  return http.request<ForgotPasswordResult>(
    "post",
    "/user/auth/forgot-password",
    { data }
  );
};

/** 验证重置令牌 */
export const validateResetTokenApi = (resetToken: string) => {
  return http.request<ValidateResetTokenResult>(
    "get",
    `/user/auth/validate-reset-token?resetToken=${resetToken}`
  );
};

/** 重置密码 */
export const resetPasswordApi = (data: ResetPasswordRequest) => {
  return http.request<ResetPasswordResult>(
    "post",
    "/user/auth/reset-password",
    { data }
  );
};

// ==================== 工具类 ====================

/** 用户认证工具类 */
export class UserAuthUtils {
  /** 验证用户名格式 */
  static validateUserName(userName: string): boolean {
    const regex = /^[a-zA-Z0-9_]{3,20}$/;
    return regex.test(userName);
  }

  /** 验证密码格式 */
  static validatePassword(password: string): boolean {
    return password.length >= 6 && password.length <= 20;
  }

  /** 验证邮箱格式 */
  static validateEmail(email: string): boolean {
    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return regex.test(email);
  }

  /** 验证手机号格式 */
  static validatePhoneNumber(phoneNumber: string): boolean {
    const regex = /^1[3-9]\d{9}$/;
    return regex.test(phoneNumber);
  }

  /** 验证验证码格式 */
  static validateVerificationCode(code: string): boolean {
    const regex = /^\d{6}$/;
    return regex.test(code);
  }

  /** 获取验证类型描述 */
  static getVerificationTypeDescription(type: VerificationType): string {
    const descriptions = {
      [VerificationType.REGISTER]: "注册验证",
      [VerificationType.RESET_PASSWORD]: "密码重置",
      [VerificationType.CHANGE_EMAIL]: "更换邮箱"
    };
    return descriptions[type] || type;
  }

  /** 获取性别描述 */
  static getSexDescription(sex: string): string {
    const descriptions = {
      "0": "女",
      "1": "男",
      "2": "未知"
    };
    return descriptions[sex] || "未知";
  }

  /** 验证昵称格式 */
  static validateNickName(nickName: string): boolean {
    return nickName.length >= 2 && nickName.length <= 20;
  }

  /** 验证密码一致性 */
  static validatePasswordMatch(
    password: string,
    confirmPassword: string
  ): boolean {
    return password === confirmPassword;
  }

  /** 生成密码强度提示 */
  static getPasswordStrengthTip(password: string): string {
    if (password.length < 6) {
      return "密码长度至少6位";
    }
    if (password.length > 20) {
      return "密码长度不能超过20位";
    }

    let strength = 0;
    if (/[a-z]/.test(password)) strength++;
    if (/[A-Z]/.test(password)) strength++;
    if (/\d/.test(password)) strength++;
    if (/[!@#$%^&*(),.?":{}|<>]/.test(password)) strength++;

    if (strength <= 1) return "密码强度：弱";
    if (strength <= 2) return "密码强度：中";
    if (strength <= 3) return "密码强度：强";
    return "密码强度：很强";
  }

  /** 格式化错误消息 */
  static formatErrorMessage(error: any): string {
    if (typeof error === "string") {
      return error;
    }
    if (error?.response?.data?.message) {
      return error.response.data.message;
    }
    if (error?.message) {
      return error.message;
    }
    return "操作失败，请稍后重试";
  }

  /** 检查Token是否即将过期 */
  static isTokenExpiringSoon(
    expireTime: number,
    thresholdMinutes: number = 30
  ): boolean {
    const now = Math.floor(Date.now() / 1000);
    const threshold = thresholdMinutes * 60;
    return expireTime - now <= threshold;
  }

  /** 格式化剩余时间 */
  static formatRemainingTime(seconds: number): string {
    if (seconds <= 0) return "已过期";

    const hours = Math.floor(seconds / 3600);
    const minutes = Math.floor((seconds % 3600) / 60);
    const secs = seconds % 60;

    if (hours > 0) {
      return `${hours}小时${minutes}分钟`;
    } else if (minutes > 0) {
      return `${minutes}分钟${secs}秒`;
    } else {
      return `${secs}秒`;
    }
  }
}
